home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / music / eked-m1.zoo / src / effect.c < prev    next >
C/C++ Source or Header  |  1995-02-19  |  6KB  |  203 lines
  1. /*
  2.  *  EKED-M1 : Editor for Korg M1 synth; effect.c : effect parameter management
  3.  *  Copyright (C) 1995 Steven M. Eker (Steven.Eker@brunel.ac.uk)
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. #include <stddef.h>
  21. #include <string.h>
  22. #include <gemfast.h>
  23. #include <aesbind.h>
  24. #include "gm/gem_man.h"
  25. #include "eked-m1.h"
  26. #include "defs.h"
  27. #include "types.h"
  28. #include "externs.h"
  29.  
  30. static int epn_table[] =
  31. {
  32.   -1,    0,     -1,     4,
  33.   -1,    1,     -1,     5,
  34.   -1,    2,     -1,     6,
  35.   -1,    3,     -1,     7
  36. };
  37.  
  38. static int eob_table[] =
  39. {
  40.   0,    4,    8,    12,
  41.   2,    6,    10,    14
  42. };
  43.  
  44. static void effect_update(OBJECT *object, int value);
  45. static void epara_default(int unit, BYTE *data);
  46. static void epara_fixup(OBJECT *tree, int unit, BYTE *data);
  47.  
  48. void eroute_edit(int handle, OBJECT *tree, int base_page, int m_x, int m_y,
  49.                  BYTE data[])
  50. {
  51.   int ob = objc_find(tree, 0, MAX_DEPTH, m_x, m_y);
  52.  
  53.   switch(ob){
  54.   case ER_EFFECT1:
  55.     para_edit(handle, tree, ob, BIT0, base_page, 13, data + 8);
  56.     data[8] = REPLACE_BIT(data[8], 1, EXTRACT_BIT(data[8], 0));
  57.     break;
  58.   case ER_EFFECT2:
  59.     para_edit(handle, tree, ob, BIT2, base_page + 2, 13, data + 8);
  60.     data[8] = REPLACE_BIT(data[8], 3, EXTRACT_BIT(data[8], 2));
  61.     break;
  62.   case ER_MODE:
  63.     para_edit(handle, tree, ob, ROUT, base_page + 4, 8, data + 8);
  64.     break;
  65.   case ER_PAN3:
  66.     para_edit(handle, tree, ob, PAN, base_page + 4, 12, data + 6);
  67.     break;
  68.   case ER_PAN4:
  69.     para_edit(handle, tree, ob, PAN, base_page + 4, 14, data + 7);
  70.     break;
  71.   }
  72. }
  73.  
  74. void eroute_setup(OBJECT *tree, BYTE data[])
  75. {
  76.   para_fill(tree + ER_EFFECT1, BIT0, data + 8);
  77.   para_fill(tree + ER_EFFECT2, BIT2, data + 8);
  78.   para_fill(tree + ER_MODE, ROUT, data + 8);
  79.   para_fill(tree + ER_PAN3, PAN, data + 6);
  80.   para_fill(tree + ER_PAN4, PAN, data + 7);
  81. }
  82.  
  83. void effect_edit(int handle, OBJECT *tree, int unit, int base_page,
  84.                  int m_x, int m_y, BYTE data[])
  85. {
  86.   int ob = objc_find(tree, 0, MAX_DEPTH, m_x, m_y);
  87.   int e_type = data[unit];
  88.   int new, p_nr, i, offset;
  89.  
  90.   if(ob == EFFECT_TYPE){
  91.     new = wm_roll(handle, tree, ob, e_type, 0, 33, &effect_update);
  92.     if(new != e_type){
  93.       data[unit] = new;
  94.       tx_para_chg(base_page + 2 * unit, 8, new);
  95.       epara_default(unit, data);        /* data array to defaults */
  96.       epara_fixup(tree, unit, data);        /* update resource tree */
  97.       wm_ob_update(handle, tree, E_PARA_BLOCK);    /* redraw parameter block */
  98.     }
  99.     return;
  100.   }
  101.   p_nr = ob - (E_PARA_BLOCK + 1);    /* extract parameter number 0..7 */
  102.   if(p_nr < 0 || p_nr > 15 || (p_nr = epn_table[p_nr]) < 0)
  103.     return;
  104.   i = effect_table[e_type].param[p_nr].data_pos;
  105.   switch(i){
  106.   case SBAL:
  107.   case LBAL:
  108.     offset = 2 + 2 * unit;
  109.     break;
  110.   case RBAL:
  111.     offset = 3 + 2 * unit;
  112.     break;
  113.   default:
  114.     offset = i + 9 + 8 * unit;
  115.   }
  116.   para_edit(handle, tree, ob, effect_table[e_type].param[p_nr].type,
  117.             base_page + 1 + 2 * unit, p_nr + 8, data + offset);
  118.   if(i == SBAL)
  119.     data[offset + 1] = data[offset];
  120. }
  121.  
  122. static void epara_default(int unit, BYTE *data)
  123. {
  124.   int e_type = data[unit];
  125.   EPARAMETER *p = effect_table[e_type].param;
  126.   PARA_TYPE t;
  127.   int i, j, offset;
  128.  
  129.   for(j = 0; j <= 7; j++){
  130.     t = p[j].type;
  131.     if(t != NPRM){
  132.       i = p[j].data_pos;
  133.       switch(i){
  134.       case SBAL:
  135.       case LBAL:
  136.         offset = 2 + 2 * unit;
  137.         break;
  138.       case RBAL:
  139.         offset = 3 + 2 * unit;
  140.         break;
  141.       default:
  142.         offset = i + 9 + 8 * unit;
  143.       }
  144.       data[offset] = p[j].def_val;
  145.       if(i == SBAL)
  146.         data[offset + 1] = data[offset];
  147.       else if(t == DEL4)
  148.         data[offset + 1] = p[j].def_val >> 8;
  149.     }
  150.   }
  151.   if(e_type + 1 == 31)    /* Delay/Flanger needs flanger waveform selected */
  152.     data[6 + 9 + 8 * unit] = 4;
  153. }
  154.  
  155. static void epara_fixup(OBJECT *tree, int unit, BYTE *data)
  156. {
  157.   EPARAMETER *p = effect_table[data[unit]].param;
  158.   int i, j, k;
  159.   PARA_TYPE t;
  160.   char *s;
  161.  
  162.   tree += E_PARA_BLOCK + 1;
  163.   for(j = 0; j <= 7; j++){
  164.     k = eob_table[j];
  165.     t = p[j].type;
  166.     if(t == NPRM){
  167.       tree[k].ob_flags |= HIDETREE;
  168.       tree[k + 1].ob_flags |= HIDETREE;
  169.     }
  170.     else{
  171.       i = p[j].data_pos;
  172.       switch(i){
  173.       case SBAL:
  174.       case LBAL:
  175.         i = 2 + 2 * unit;
  176.         break;
  177.       case RBAL:
  178.         i = 3 + 2 * unit;
  179.         break;
  180.       default:
  181.         i += 9 + 8 * unit;
  182.       }
  183.       tree[k].ob_flags &= ~HIDETREE;
  184.       strcpy(STRING_PTR(tree, k), p[j].name);
  185.       tree[k + 1].ob_flags &= ~HIDETREE;
  186.       s = TEXT_PTR(tree, k + 1);
  187.       s[0] = s[1] = s[2] = s[3] = s[4] = ' ';
  188.       para_fill(tree + k + 1, t, data + i);
  189.     }
  190.   }
  191. }
  192.  
  193. void epara_setup(OBJECT *tree, int unit, BYTE data[])
  194. {
  195.   effect_update(tree + EFFECT_TYPE, (int) data[unit]);
  196.   epara_fixup(tree, unit, data);
  197. }
  198.  
  199. static void effect_update(OBJECT *object, int value)
  200. {
  201.   (void) strcpy(TEXT_PTR(object, 0), effect_table[value].name);
  202. }
  203.